package pc

import (
	. "chess_platform/internal/common"
	"chess_platform/models/client"
	"chess_platform/models/pc"
	"fmt"
	"time"
)

//[pc]run:运营管理
type RunController struct {
	GrantController
}

func (b *RunController) URLMapping() {
	//game-charge:游戏收费配置
	b.Mapping("ListChargeGame", b.ListChargeGame)
	b.Mapping("NewUpdateRoomCard", b.NewUpdateRoomCard)
	b.Mapping("EditRoomCard", b.EditRoomCard)

	//game-publish:游戏发布
	b.Mapping("ListPublishGame", b.ListPublishGame)
	b.Mapping("PublishGame", b.PublishGame)

	//notice:公告配置
	b.Mapping("NewActivityNotice", b.NewActivityNotice)
	b.Mapping("UpdateActivityNotice", b.UpdateActivityNotice)
	b.Mapping("UpdateActivityNoticeStatus", b.UpdateActivityNoticeStatus)
	b.Mapping("ActivityNoticeInfo", b.ActivityNoticeInfo)
	b.Mapping("DeleteActivityNotice", b.DeleteActivityNotice)
	b.Mapping("ListActivityNotice", b.ListActivityNotice)

	b.Mapping("NewAgentNotice", b.NewAgentNotice)
	b.Mapping("UpdateAgentNotice", b.UpdateAgentNotice)
	b.Mapping("AgentNoticeInfo", b.AgentNoticeInfo)
	b.Mapping("DeleteAgentNotice", b.DeleteAgentNotice)
	b.Mapping("ListAgentNotice", b.ListAgentNotice)

	b.Mapping("NewGameNotice", b.NewGameNotice)
	b.Mapping("UpdateGameNotice", b.UpdateGameNotice)
	b.Mapping("GameNoticeInfo", b.GameNoticeInfo)
	b.Mapping("DeleteGameNotice", b.DeleteGameNotice)
	b.Mapping("ListGameNotice", b.ListGameNotice)
	b.Mapping("ListNoticeGame", b.ListNoticeGame)

	//game-area:地区游戏配置
	b.Mapping("ListGame", b.ListGame)
	b.Mapping("NewAreaGame", b.NewAreaGame)
	b.Mapping("UpdateAreaGame", b.UpdateAreaGame)
	b.Mapping("DeleteAreaGame", b.DeleteAreaGame)
	b.Mapping("ListAreaGame", b.ListAreaGame)

	//service:客服合作
	b.Mapping("UpdateOtherConf", b.UpdateOtherConf)
	b.Mapping("EditOtherConf", b.EditOtherConf)
	b.Mapping("ListOtherConf", b.ListOtherConf)

	//h5-notice:代理公告
	b.Mapping("NewH5Notice", b.NewH5Notice)
	b.Mapping("UpdateH5Notice", b.UpdateH5Notice)
	b.Mapping("H5NoticeInfo", b.H5NoticeInfo)
	b.Mapping("DeleteH5Notice", b.DeleteH5Notice)
	b.Mapping("ListH5Notice", b.ListH5Notice)

	//horse:跑马灯设置
	b.Mapping("NewHorse", b.NewHorse)
	b.Mapping("UpdateHorse", b.UpdateHorse)
	b.Mapping("DeleteHorse", b.DeleteHorse)
	b.Mapping("ListHorse", b.ListHorse)
	b.Mapping("PushHorse", b.PushHorse)

	//email-full:全服邮件
	b.Mapping("NewEmailFull", b.NewEmailFull)
	b.Mapping("UpdateEmailFull", b.UpdateEmailFull)
	b.Mapping("UpdateEmailFullStatus", b.UpdateEmailFullStatus)
	b.Mapping("DeleteEmailFull", b.DeleteEmailFull)
	b.Mapping("EmailFullInfo", b.EmailFullInfo)
	b.Mapping("ListEmailFull", b.ListEmailFull)

	//email:邮件单发
	b.Mapping("NewEmail", b.NewEmail)
	b.Mapping("UpdateEmail", b.UpdateEmail)
	b.Mapping("DeleteEmail", b.DeleteEmail)
	b.Mapping("EmailInfo", b.EmailInfo)
	b.Mapping("ListEmail", b.ListEmail)

	//feedback:用户反馈
	b.Mapping("UpdateFeedbackStatus", b.UpdateFeedbackStatus)
	b.Mapping("ListFeedback", b.ListFeedback)

	//white:上下分白名单
	b.Mapping("AddWhiteUser", b.AddWhiteUser)
	b.Mapping("UpdateWhiteUser", b.UpdateWhiteUser)
	b.Mapping("ListWhiteUser", b.ListWhiteUser)
	b.Mapping("DeleteWhiteUser", b.DeleteWhiteUser)
	b.Mapping("QueryUserInfo", b.QueryUserInfo)

	//group-game:大区游戏
	b.Mapping("AddGroupGame", b.AddGroupGame)
	b.Mapping("ListGroupGame", b.ListGroupGame)
	b.Mapping("DeleteGroupGame", b.DeleteGroupGame)
}

// @Title 游戏列表
// @Description 游戏列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.GameList 游戏列表
// @router /game-charge/list-game [post]
func (b *RunController) ListChargeGame() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGame(p, 0)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 新建或更新房间钻石配置(传[{},{}]的json字符串格式)
// @Description 新建或更新房间钻石配置(传[{},{}]的json字符串格式)
// @Param   id           body   int        true        "id,-1表示新建"
// @Param   game_type    body   int        true        "游戏类型(更新时也要传,用来更新缓存)"
// @Param   play_type    body   int        true        "玩法(更新时也要传,用来更新缓存)"
// @Param   round        body   int        true        "局数"
// @Param   card         body   int        true        "(房主支付)钻石数量,card == 0表示免费,-1表示没有填这个选项"
// @Param   card_aa      body   int        true        "(AA支付)钻石数量"
// @Param   idx          body   int        true        "收费编排顺序1,2,3....."
// @Success 0 {string}  状态码
// @router /game-charge/new-update-room-card [post]
func (b *RunController) NewUpdateRoomCard() {
	type Params struct {
		RoomCard []RoomCard `json:"room_card"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	//card == 0表示免费,-1表示没有填这个选项
	var gameId int64
	for _, v := range p.RoomCard {
		if v.GameType == 0 && v.PlayType == 0 {
			b.ResponseFail("请传game_type与play_type")
			return
		}
		gameId = GenGameId(v.GameType, v.PlayType)
		if v.Card == -1 && v.CardAa == -1 && v.Id == -1 && v.Round == 0 { //round(局数)是必须的,为0表示
			continue
		}
		if v.Idx < 1 { //idx的值只允许1及1以上
			b.ResponseFail("idx的值只允许1及1以上")
			return
		}
		data := map[string]interface{}{
			"game_type": v.GameType,
			"play_type": v.PlayType,
			"game_id":   gameId,
			"idx":       v.Idx,
			"round":     v.Round,
			"card":      v.Card,
			"card_aa":   v.CardAa,
		}
		if v.Id == -1 && (v.Round != 0 && (v.CardAa != -1 || v.Card != -1)) { //新建
			_, err := pc.NewRoomCard(data)
			if err != nil {
				LogPc.Error(b.DatabaseError(err.Error()))
				return
			}
			msg := fmt.Sprintf("新增钻石收费,游戏(ID:%v)", gameId)
			b.NewLog(LogGameConfig, OpNew, msg, data)
		} else { //更新
			delete(data, "game_type")
			delete(data, "play_type")
			delete(data, "game_id")

			if v.Round == 0 || (v.Card == -1 && v.CardAa == -1) { //表示需要删除这一行
				_, err := pc.DeleteRoomCard(v.Id)
				if err != nil {
					LogPc.Error(b.DatabaseError(err.Error()))
					return
				}
				msg := fmt.Sprintf("删除钻石收费,游戏(ID:%v)", gameId)
				b.NewLog(LogGameConfig, OpDelete, msg, data)
			} else { //更新此行
				err := pc.UpdateRoomCard(data, v.Id)
				if err != nil {
					LogPc.Error(b.DatabaseError(err.Error()))
					return
				}
				msg := fmt.Sprintf("更新钻石收费,游戏(ID:%v)", gameId)
				b.NewLog(LogGameConfig, OpUpdate, msg, data)
			}

		}

	}
	Key := fmt.Sprintf("%v%v", KeyRoomCard, gameId)
	Redis.Del(Key)

	DeleteGameCache(NationCode)
	if !client.NotifyReloadConfig() {
		LogPc.Error("游戏服务器返回失败,通知加载钻石配置文件失败")
		b.ResponseFail("游戏服务器返回失败,通知加载钻石配置文件失败")
		return
	}
	b.ResponseSuccess()
}

// @Title 获取房间钻石配置列表
// @Description  获取房间钻石配置列表
// @Param   game_id    body   int        true        "游戏id"
// @Success 0 {object} []common.RoomCard 房间钻石列表
// @Failure 399
// @router /game-charge/edit-room-card [post]
func (b *RunController) EditRoomCard() {
	type Params struct {
		GameId int64 `json:"game_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	rc, err := pc.RoomCardById(p.GameId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = rc
	b.ResponseSuccess()
}

// @Title 游戏列表(游戏发布)
// @Description 游戏列表(游戏发布)
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.GameList 游戏列表
// @router /game-publish/list-game [post]
func (b *RunController) ListPublishGame() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGame(p, 0)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 发布游戏(上线,下线)
// @Description 发布游戏(上线,下线)
// @Param   game_id           body   int        true       "game_id"
// @Param   is_publish   	  body   int        true       "是否发布游戏, 1-是，0-否"
// @Success 0 {string}  状态码
// @router /game-publish/publish-game [post]
func (b *RunController) PublishGame() {
	type Params struct {
		GameId    int64 `json:"game_id" valid:"Required"`
		IsPublish int64 `json:"is_publish" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"is_publish": p.IsPublish,
	}
	msg := fmt.Sprintf("下架游戏(游戏ID:%v)", p.GameId)
	if p.IsPublish == 1 {
		data["publish_time"] = time.Now().Unix()
		msg = fmt.Sprintf("上架游戏(游戏ID:%v)", p.GameId)
	}
	_, err := pc.UpdateGame(data, p.GameId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//删除所有的城市编码的游戏缓存
	DeleteGameCache(NationCode)
	b.NewLog(LogGameConfig, OpUpdate, msg, map[string]interface{}{})
}

// @Title 添加公告(1-活动公告,2-系统公告)
// @Description 添加公告(1-活动公告,2-系统公告)
// @Param   type         body   int        true       "1-活动公告,2-系统公告"
// @Param   title        body   string     true       "标题(最多6个字符)"
// @Param   notice_url   body   string     false      "公告图片url"
// @Param   detail_url   body   string     false      "公告详情跳转的url"
// @Param   content      body   string     true       "内容"
// @Param   show_now     body   int        true       "登录时弹出的公告, 0-普通,不弹，1-每次登录弹,2-每天首次登录弹"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Param   expire_time  body   int        true       "过期时间(时间戳)"
// @Success 0 {string}  状态码
// @router /notice/new-activity-notice [post]
func (b *RunController) NewActivityNotice() {
	var p ActivityNotice
	if !b.DecodeParams(&p) {
		return
	}
	if p.NoticeUrl != "" && p.DetailUrl != "" {
		b.ResponseFail("公告图片或公告详情只能配一个")
		return
	}
	b.Valid.Range(p.Type, 1, 2, "type").Message("1-活动公告,2-系统公告")
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.MaxSize(p.Title, 6, "title").Message("公告标题最多为6个字符")
	b.Valid.Range(p.ShowNow, 0, 2, "show_now").Message("登录时弹出的公告, 0-普通,不弹，1-每次登录弹,2-每天首次登录弹")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("公告过期时间为必填")
	if !b.VerifyParamsError() {
		return
	}

	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"type":         p.Type,
		"title":        p.Title,
		"notice_url":   p.NoticeUrl,
		"detail_url":   p.DetailUrl,
		"content":      p.Content,
		"show_now":     p.ShowNow,
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewNotice(data, TableActivityNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	b.ResponseSuccess()
	DelCache(RedisCache, KeyNotice)
	msg := fmt.Sprintf("新增活动公告(标题:%v)", p.Title)
	if p.Type == 2 {
		msg = fmt.Sprintf("新增系统公告(标题:%v)", p.Title)
	}

	b.NewLog(LogGameConfig, OpNew, msg, data)
}

// @Title 更新活动公告
// @Description 更新活动公告
// @Param   id           body   int        true       "id"
// @Param   type         body   int        true       "1-活动公告,2-系统公告"
// @Param   title        body   string     true       "标题"
// @Param   notice_url   body   string     false      "公告图片url"
// @Param   detail_url   body   string     false      "公告详情跳转的url"
// @Param   content      body   string     true       "内容"
// @Param   show_now     body   int        true       "登录时弹出的公告, 0-普通,不弹，1-每次登录弹,2-每天首次登录弹"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Param   expire_time  body   int        true       "过期时间(时间戳)"
// @Success 0 {string}  状态码
// @router /notice/update-activity-notice [post]
func (b *RunController) UpdateActivityNotice() {
	var p ActivityNotice
	if !b.DecodeParams(&p) {
		return
	}
	if p.NoticeUrl != "" && p.DetailUrl != "" {
		b.ResponseFail("公告图片或公告详情只能配一个")
		return
	}

	b.Valid.Range(p.Type, 1, 2, "type").Message("1-活动公告,2-系统公告")
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.MaxSize(p.Title, 6, "title").Message("公告标题最多为6个字符")
	b.Valid.Range(p.ShowNow, 0, 2, "show_now").Message("登录时弹出的公告, 0-普通,不弹，1-每次登录弹,2-每天首次登录弹")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("公告过期时间为必填")
	if !b.VerifyParamsError() {
		return
	}

	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"type":         p.Type,
		"title":        p.Title,
		"notice_url":   p.NoticeUrl,
		"detail_url":   p.DetailUrl,
		"content":      p.Content,
		"show_now":     p.ShowNow,
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
	}
	_, err := pc.UpdateNotice(data, p.Id, TableActivityNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	DelCache(RedisCache, KeyNotice)

	msg := fmt.Sprintf("更新活动公告(ID:%v标题:%v)", p.Id, p.Title)
	if p.Type == 2 {
		msg = fmt.Sprintf("更新系统公告(ID:%v,标题:%v)", p.Id, p.Title)
	}
	b.NewLog(LogGameConfig, OpUpdate, msg, data)

}

// @Title 更新活动公告(系统公告,游戏公告)状态
// @Description 更新活动公告(系统公告,游戏公告)状态
// @Param   id           body   int        true       "id"
// @Param   status       body   int        true       "此公告的状态(0正常,1下架)"
// @Success 0 {string}  状态码
// @router /notice/update-activity-notice-status [post]
func (b *RunController) UpdateActivityNoticeStatus() {
	type Params struct {
		Id     int64 `json:"id" valid:"Required"`
		Status int64 `json:"status" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	data := map[string]interface{}{
		"status":      p.Status,
		"modify_time": time.Now().Unix(),
	}
	_, err := pc.UpdateNotice(data, p.Id, TableActivityNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	DelCache(RedisCache, KeyNotice)

	msg := fmt.Sprintf("更新活动公告(ID:%v状态为正常)", p.Id)
	if p.Status == 1 {
		msg = fmt.Sprintf("更新活动公告(ID:%v状态为下架)", p.Id)
	}
	b.NewLog(LogGameConfig, OpUpdate, msg, data)

}

// @Title 获取活动公告信息
// @Description 获取活动公告信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.Notice 公告信息
// @router /notice/activity-notice-info [post]
func (b *RunController) ActivityNoticeInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	notice, err := pc.ActivityNoticeInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = notice
	b.ResponseSuccess()
}

// @Title 删除活动公告
// @Description 删除活动公告
// @Param   id           body   int        true       "id"
// @Success 0 {string}  状态码
// @router /notice/delete-activity-notice [post]
func (b *RunController) DeleteActivityNotice() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteNotice(p.Id, TableActivityNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	DelCache(RedisCache, KeyNotice)
	msg := fmt.Sprintf("删除公告(ID:%v)", p.Id)
	b.NewLog(LogGameConfig, OpDelete, msg, map[string]interface{}{})
}

// @Title 活动公告列表
// @Description 活动公告列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.ActivityNotice 公告列表
// @router /notice/list-activity-notice [post]
func (b *RunController) ListActivityNotice() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListActivityNotice(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	// 1-未启用,2-启用中,3-已过期
	now := time.Now().Unix()
	for _, v := range data {
		if v.PublishTime > now { //未启用
			v.PublishStatus = 1
		} else if v.ExpireTime < now { //已过期
			v.PublishStatus = 3
		} else { //启用中
			v.PublishStatus = 2
		}
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

//-------------------------------------以下是游戏招募代理公告---------------------------

// @Title 添加游戏招募代理公告
// @Description 添加游戏招募代理公告
// @Param   game_id      body   int        true      "游戏id"
// @Param   content      body   string     true       "内容"
// @Success 0 {string}  状态码
// @router /notice/new-agent-notice [post]
func (b *RunController) NewAgentNotice() {
	var p AgentNotice
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	if pc.IsAgentNoticeExistByGameId(p.GameId) {
		b.ResponseFail("游戏招募代理公告已存在")
		return
	}

	data := map[string]interface{}{
		"game_id":     p.GameId,
		"content":     p.Content,
		"modify_time": time.Now().Unix(),
		"create_time": time.Now().Unix(),
	}
	_, err := pc.NewNotice(data, TableAgentNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	//删除掉缓存里的空结果
	Key := fmt.Sprintf("%v%v", KeyAgentNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("新增游戏招募代理公告(游戏ID:%v)", p.GameId)
	b.NewLog(LogGameConfig, OpNew, msg, data)
}

// @Title 更新子游戏大厅游戏招募代理公告
// @Description 更新子游戏大厅游戏招募代理公告
// @Param   id           body   int        true      "id"
// @Param   game_id      body   int        true      "游戏id"
// @Param   content      body   string     true      "内容"
// @Success 0 {string}  状态码
// @router /notice/update-agent-notice [post]
func (b *RunController) UpdateAgentNotice() {
	var p AgentNotice
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("ID不能为空")
	if !b.ValidParams(&p) {
		return
	}

	data := map[string]interface{}{
		"game_id":     p.GameId,
		"content":     p.Content,
		"modify_time": time.Now().Unix(),
	}
	_, err := pc.UpdateNotice(data, p.Id, TableAgentNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//游戏公告更新之后,1.要删除缓存,2.要发送通知能客户端来拉取最新的游戏公告
	Key := fmt.Sprintf("%v%v", KeyAgentNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("更新游戏招募代理公告(游戏ID:%v)", p.GameId)
	b.NewLog(LogGameConfig, OpUpdate, msg, data)
}

// @Title 获取子游戏大厅里游戏招募代理公告信息
// @Description 获取子游戏大厅里游戏招募代理公告信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.AgentNotice 公告信息
// @router /notice/agent-notice-info [post]
func (b *RunController) AgentNoticeInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	notice, err := pc.AgentNoticeInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = notice
	b.ResponseSuccess()
}

// @Title 删除子游戏大厅里游戏招募代理公告
// @Description 删除子游戏大厅里游戏招募代理公告
// @Param   id                body   int        true       "id"
// @Param   game_id           body   int        true       "游戏id"
// @Success 0 {string}  状态码
// @router /notice/delete-agent-notice [post]
func (b *RunController) DeleteAgentNotice() {
	type Params struct {
		Id     int64 `json:"id" valid:"Required"`
		GameId int64 `json:"game_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteNotice(p.Id, TableAgentNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	Key := fmt.Sprintf("%v%v", KeyAgentNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("删除游戏招募代理公告(游戏ID:%v)", p.GameId)
	b.NewLog(LogGameConfig, OpDelete, msg, map[string]interface{}{})
}

// @Title 子游戏大厅里游戏招募代理公告列表
// @Description 子游戏大厅里游戏招募代理公告列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.AgentNotice 公告列表
// @router /notice/list-agent-notice [post]
func (b *RunController) ListAgentNotice() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListAgentNotice(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

//-------------------------以下是子游戏大厅里的游戏公告--------------------------------------
// @Title 添加子游戏大厅游戏公告
// @Description 添加子游戏大厅游戏公告
// @Param   game_id      body   int        true       "游戏id,0-所有游戏"
// @Param   title        body   string     true       "标题"
// @Param   notice_url   body   string     true       "公告图片url"
// @Param   detail_url   body   string     true       "活动详情跳转url"
// @Param   content      body   string     true       "内容"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Param   expire_time  body   int        true       "过期时间(时间戳)"
// @Success 0 {string}  状态码
// @router /notice/new-game-notice [post]
func (b *RunController) NewGameNotice() {
	var p GameNotice
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.MaxSize(p.Title, 6, "title").Message("公告标题最多为6个字符")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("公告过期时间为必填")
	if !b.VerifyParamsError() {
		return
	}
	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"game_id":      p.GameId,
		"title":        p.Title,
		"notice_url":   p.NoticeUrl,
		"detail_url":   p.DetailUrl,
		"content":      p.Content,
		"status":       0, //正常
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewNotice(data, TableGameNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	Key := fmt.Sprintf("%v%v", KeyGameNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("新增子游戏大厅游戏公告(游戏ID:%v,标题:%v)", p.GameId, p.Title)
	b.NewLog(LogGameConfig, OpNew, msg, data)
}

// @Title 更新子游戏大厅游戏公告
// @Description 更新子游戏大厅游戏公告
// @Param   id           body   int        true       "id"
// @Param   game_id      body   int        true       "游戏id,0-所有游戏"
// @Param   title        body   string     true       "标题"
// @Param   notice_url   body   string     true       "公告图片url"
// @Param   detail_url   body   string     true       "活动详情跳转url"
// @Param   content      body   string     true       "内容"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Param   expire_time  body   int        true       "过期时间(时间戳)"
// @Success 0 {string}  状态码
// @router /notice/update-game-notice [post]
func (b *RunController) UpdateGameNotice() {
	var p GameNotice
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为空")
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.MaxSize(p.Title, 6, "title").Message("公告标题最多为6个字符")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("公告过期时间为必填")
	if !b.VerifyParamsError() {
		return
	}

	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"game_id":      p.GameId,
		"title":        p.Title,
		"notice_url":   p.NoticeUrl,
		"detail_url":   p.DetailUrl,
		"content":      p.Content,
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
	}
	_, err := pc.UpdateNotice(data, p.Id, TableGameNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//游戏公告更新之后,1.要删除缓存,2.要发送通知能客户端来拉取最新的游戏公告
	Key := fmt.Sprintf("%v%v", KeyGameNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("更新子游戏大厅游戏公告(游戏ID:%v,标题:%v)", p.GameId, p.Title)
	b.NewLog(LogGameConfig, OpUpdate, msg, data)
}

// @Title 获取子游戏大厅游戏公告信息
// @Description 获取子游戏大厅游戏公告信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.Notice 公告信息
// @router /notice/game-notice-info [post]
func (b *RunController) GameNoticeInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	notice, err := pc.GameNoticeInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = notice
	b.ResponseSuccess()
}

// @Title 删除子游戏大厅游戏公告
// @Description 删除子游戏大厅游戏公告
// @Param   id                body   int        true       "id"
// @Param   game_id           body   int        true       "游戏id"
// @Success 0 {string}  状态码
// @router /notice/delete-game-notice [post]
func (b *RunController) DeleteGameNotice() {
	type Params struct {
		Id     int64 `json:"id" valid:"Required"`
		GameId int64 `json:"game_id"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteNotice(p.Id, TableGameNotice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	Key := fmt.Sprintf("%v%v", KeyGameNotice, p.GameId)
	DelCache(RedisCache, Key)

	msg := fmt.Sprintf("删除子游戏大厅游戏公告(ID:%v,游戏ID:%v)", p.Id, p.GameId)
	b.NewLog(LogGameConfig, OpDelete, msg, map[string]interface{}{})
}

// @Title 子游戏大厅游戏公告列表
// @Description 子游戏大厅游戏公告列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.GameNotice 公告列表
// @router /notice/list-game-notice [post]
func (b *RunController) ListGameNotice() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGameNotice(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	// 1-未启用,2-启用中,3-已过期
	now := time.Now().Unix()
	for _, v := range data {
		if v.PublishTime > now { //未启用
			v.PublishStatus = 1
		} else if v.ExpireTime < now { //已过期
			v.PublishStatus = 3
		} else { //启用中
			v.PublishStatus = 2
		}
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 游戏列表(游戏公告)
// @Description 游戏列表(游戏公告)
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.GameList 游戏列表
// @router /notice/list-game [post]
func (b *RunController) ListNoticeGame() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGame(p, 0)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 游戏列表(地区配置)
// @Description 游戏列表(地区配置)
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.GameList 游戏列表
// @router /game-area/list-game [post]
func (b *RunController) ListGame() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGame(p, 0)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 添加区域游戏
// @Description 添加区域游戏
// @Param   city_code    body   int        true       "市级编码,999999-全国"
// @Param   position     body   int        true       "排序，1,2,3,4,5,6,7,8....,9999表示默认排序"
// @Param   game_id      body   int        true       "游戏id"
// @Success 0 {string}  状态码
// @router /game-area/new-area-game [post]
func (b *RunController) NewAreaGame() {
	var p AreaGameList
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.CityCode, "city_code").Message("城市编码不能为0")
	b.Valid.Required(p.GameId, "game_id").Message("游戏id不能为0")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"city_code":     p.CityCode,
		"district_code": p.DistrictCode,
		"position":      p.Position,
		"game_id":       p.GameId,
	}
	if p.Position == 0 {
		data["position"] = OrderCode
	}
	//先判断游戏是否存在了
	if pc.IsAreaGameExist(p.GameId, p.CityCode) {
		b.ResponseFail("此游戏已存在")
		return
	}

	_, err := pc.NewAreaGame(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//删除有关此城市编码的游戏缓存
	DeleteGameCache(p.CityCode)
	msg := fmt.Sprintf("添加区域(城市编码:%v)游戏(游戏ID:%v)", p.CityCode, p.GameId)
	b.NewLog(LogGameConfig, OpNew, msg, data)
}

// @Title 更新区域游戏
// @Description 更新区域游戏
// @Param   id           body   int        true        "id"
// @Param   city_code    body   int        true       "市级编码,999999-全国(麻烦传一下,清理缓存要用得着)"
// @Param   position     body   int        true        "排序，1,2,3,4,5,6,7,8....,9999表示默认排序"
// @Success 0 {string}  状态码
// @router /game-area/update-area-game [post]
func (b *RunController) UpdateAreaGame() {
	type Params struct {
		Id       int64 `json:"id" valid:"Required"`
		CityCode int64 `json:"city_code" valid:"Required"`
		Position int64 `json:"position"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"position": p.Position,
	}
	if p.Position == 0 {
		data["position"] = 9999
	}
	err := pc.UpdateAreaGame(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	//删除有关此城市编码的游戏缓存
	DeleteGameCache(p.CityCode)
	msg := fmt.Sprintf("更新区域游戏(ID:%v)排序为:%v", p.Id, p.Position)
	b.NewLog(LogGameConfig, OpUpdate, msg, data)
}

// @Title 删除区域游戏
// @Description 删除区域游戏
// @Param   id         body   int        true        "id"
// @Param   city_code  body   int        true        "市级编码,999999-全国"
// @Param   game_id    body   int        true        "游戏id"
// @Success 0 {string}  状态码
// @router /game-area/delete-area-game [post]
func (b *RunController) DeleteAreaGame() {
	type Params struct {
		Id       int64 `json:"id" valid:"Required"`
		CityCode int64 `json:"city_code" valid:"Required"`
		GameId   int64 `json:"game_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteAreaGame(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()

	//删除有关此城市编码的游戏缓存
	DeleteGameCache(p.CityCode)
	msg := fmt.Sprintf("删除区域(城市编码:%v)游戏(游戏ID:%v)", p.CityCode, p.GameId)
	b.NewLog(LogGameConfig, OpDelete, msg, map[string]interface{}{})

}

// @Title 区域游戏列表
// @Description 区域游戏列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   city_code    body   int     true       "市code,999999-全国"
// @Success 0 {object} []common.AreaGameList 区域游戏列表
// @router /game-area/list-area-game [post]
func (b *RunController) ListAreaGame() {
	type Params struct {
		ListParams
		CityCode int64 `json:"city_code" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListAreaGame(p.ListParams, p.CityCode)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 更新其它配置(开屏广告,客服,合作)
// @Description 更新其它配置(开屏广告,客服,合作)
// @Param   id           body   int        true       "id"
// @Param   type         body   int        true       "类型,2-开屏广告,3-客服,4-合作(代理),5-合作(商务)"
// @Param   name         body   string     false      "名字"
// @Param   value        body   string     false      "对应的值"
// @Param   url          body   string     false      "值对应的url"
// @Success 0 {string}  状态码
// @router /service/update-other-conf [post]
func (b *RunController) UpdateOtherConf() {
	var p OtherConf
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"type":  p.Type,
		"name":  p.Name,
		"value": p.Value,
		"url":   p.Url,
	}
	err := pc.UpdateOtherConf(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	b.ResponseSuccess()
	for i := 0; i <= 5; i++ {
		key := fmt.Sprintf("%v%v", KeyOtherConfig, i)
		DelCache(RedisCache, key)
	}

	var msg string
	switch p.Type {
	case 2:
		msg = fmt.Sprintf("更新开屏广告")
	case 3:
		msg = fmt.Sprintf("更新客服信息(ID:%v)", p.Id)
	case 4:
		msg = fmt.Sprintf("更新代理咨询")
	case 5:
		msg = fmt.Sprintf("更新商务咨询")
	}
	b.NewLog(LogPcUser, OpUpdate, msg, data)
}

// @Title 编辑其它配置(开屏广告,客服,合作)
// @Description 编辑其它配置(开屏广告,客服,合作)
// @Param   id           body   int        true       "id"
// @Success 0 {string}  状态码
// @router /service/edit-other-conf [post]
func (b *RunController) EditOtherConf() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.OtherConfById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title 其它配置列表(开屏广告,客服,合作)
// @Description 其它配置列表(开屏广告,客服,合作)
// @Param   type     body   int     true       "类型,0-所有,2-开屏广告,3-客服,4-合作(代理),5-合作(商务)"
// @Success 0 {object} []common.OtherConf 其它配置列表
// @router /service/list-other-conf [post]
func (b *RunController) ListOtherConf() {
	type Params struct {
		Type int64 `json:"type" valid:"Range(0,5)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.ListOtherConf(p.Type)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

//-----------------------以下是h5代理公告--------------------
// @Title 添加h5公告
// @Description  添加h5公告
// @Param   title        body   string     true       "标题"
// @Param   content      body   string     true       "内容"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Success 0 {string}  状态码
// @router /h5-notice/new-h5-notice [post]
func (b *RunController) NewH5Notice() {
	var p H5Notice
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	if !b.VerifyParamsError() {
		return
	}

	data := map[string]interface{}{
		"title":        p.Title,
		"content":      p.Content,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewNotice(data, TableH5Notice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	//游戏公告更新之后,1.要删除缓存,2.要发送通知能客户端来拉取最新的游戏公告
	DelCache(RedisCache, KeyH5Notice)

	msg := fmt.Sprintf("新增H5公告(标题:%v)", p.Title)
	b.NewLog(LogGameConfig, OpNew, msg, data)
}

// @Title 更新H5公告
// @Description 更新H5公告
// @Param   id           body   int        true       "id"
// @Param   title        body   string     true       "标题"
// @Param   content      body   string     true       "内容"
// @Param   publish_time body   int        true       "公告发布时间(时间戳)"
// @Success 0 {string}  状态码
// @router /h5-notice/update-h5-notice [post]
func (b *RunController) UpdateH5Notice() {
	var p H5Notice
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为空")
	b.Valid.Required(p.Title, "title").Message("公告标题不能为空")
	b.Valid.Required(p.PublishTime, "publish_time").Message("公告发布时间为必填")
	if !b.VerifyParamsError() {
		return
	}

	data := map[string]interface{}{
		"title":        p.Title,
		"content":      p.Content,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
	}
	_, err := pc.UpdateNotice(data, p.Id, TableH5Notice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//游戏公告更新之后,1.要删除缓存,2.要发送通知能客户端来拉取最新的游戏公告
	DelCache(RedisCache, KeyH5Notice)
	key := fmt.Sprintf("%v%v", KeyH5NoticeId, p.Id)
	DelCache(RedisCache, key)

	msg := fmt.Sprintf("更新H5公告(标题:%v)", p.Title)
	b.NewLog(LogGameConfig, OpUpdate, msg, data)
}

// @Title 获取H5公告信息
// @Description 获取H5公告信息
// @Param   id  body    int     true      "id"
// @Success 0 {object} common.Notice 公告信息
// @router /h5-notice/h5-notice-info [post]
func (b *RunController) H5NoticeInfo() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	notice, err := pc.H5NoticeInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = notice
	b.ResponseSuccess()
}

// @Title 删除H5公告
// @Description 删除H5公告
// @Param   id                body   int        true       "id"
// @Success 0 {string}  状态码
// @router /h5-notice/delete-h5-notice [post]
func (b *RunController) DeleteH5Notice() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteNotice(p.Id, TableH5Notice)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	DelCache(RedisCache, KeyH5Notice)
	key := fmt.Sprintf("%v%v", KeyH5NoticeId, p.Id)
	DelCache(RedisCache, key)

	msg := fmt.Sprintf("删除H5公告(ID:%v)", p.Id)
	b.NewLog(LogGameConfig, OpDelete, msg, map[string]interface{}{})
}

// @Title H5公告列表
// @Description H5公告列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.H5Notice 公告列表
// @router /h5-notice/list-h5-notice [post]
func (b *RunController) ListH5Notice() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListH5Notice(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 添加跑马灯
// @Description 添加跑马灯
// @Param   type         body   int        true       "跑马灯类型,1-游戏客户端, 2-代理助手,3-合伙人系统"
// @Param   content      body   string     true       "跑马灯的内容"
// @Param   publish_time body   int        true       "发布时间"
// @Param   expire_time  body   int        true       "过期时间"
// @Success 0 {string}  状态码
// @router /horse/new-horse [post]
func (b *RunController) NewHorse() {
	var p Horse
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Content, "content").Message("跑马灯内容不能为空")
	b.Valid.Required(p.PublishTime, "publish_time").Message("发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("过期时间为必填")
	if !b.ValidParams(&p) {
		return
	}

	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"type":         p.Type,
		"content":      p.Content,
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
		"create_time":  time.Now().Unix(),
	}
	_, err := pc.NewHorse(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	b.ResponseSuccess()
	key := fmt.Sprintf("%v%v", KeyHorse, p.Type)
	DelCache(RedisCache, key)
	msg := fmt.Sprintf("新增游戏跑马灯")
	if p.Type == 2 {
		msg = fmt.Sprintf("新增代理助手跑马灯")
	}

	b.NewLog(LogHorse, OpNew, msg, data)

}

// @Title 更新跑马灯
// @Description 更新跑马灯
// @Param   id           body   int        true       "id"
// @Param   type         body   int        true       "跑马灯类型,1-游戏客户端, 2-代理助手,3-合伙人系统"
// @Param   content      body   string     true       "跑马灯的内容"
// @Param   publish_time body   int        true       "发布时间"
// @Param   expire_time  body   int        true       "过期时间"
// @Success 0 {string}  状态码
// @router /horse/update-horse [post]
func (b *RunController) UpdateHorse() {
	var p Horse
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Content, "content").Message("跑马灯内容不能为空")
	b.Valid.Required(p.PublishTime, "publish_time").Message("发布时间为必填")
	b.Valid.Required(p.ExpireTime, "expire_time").Message("过期时间为必填")
	if !b.ValidParams(&p) {
		return
	}

	if p.PublishTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"type":         p.Type,
		"content":      p.Content,
		"expire_time":  p.ExpireTime,
		"publish_time": p.PublishTime,
		"modify_time":  time.Now().Unix(),
	}
	_, err := pc.UpdateHorse(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	key := fmt.Sprintf("%v%v", KeyHorse, p.Type)
	DelCache(RedisCache, key)
	msg := fmt.Sprintf("更新游戏跑马灯")
	if p.Type == 2 {
		msg = fmt.Sprintf("更新代理助手跑马灯")
	} else if p.Type == 3 {
		msg = fmt.Sprintf("更新合伙人系统跑马灯")
	}
	b.NewLog(LogHorse, OpUpdate, msg, data)

}

// @Title 删除跑马灯
// @Description 删除跑马灯
// @Param   id           body   int        true       "id"
// @Param   type         body   int        true       "跑马灯类型,1-游戏客户端, 2-代理助手,3-合伙人系统"
// @Success 0 {string}  状态码
// @router /horse/delete-horse [post]
func (b *RunController) DeleteHorse() {
	type Params struct {
		Id   int64 `json:"id" valid:"Required"`
		Type int64 `json:"type" valid:"Range(1,3)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	_, err := pc.DeleteHorse(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	key := fmt.Sprintf("%v%v", KeyHorse, p.Type)
	DelCache(RedisCache, key)
	msg := fmt.Sprintf("删除游戏跑马灯")
	if p.Type == 2 {
		msg = fmt.Sprintf("删除代理助手跑马灯")
	} else if p.Type == 3 {
		msg = fmt.Sprintf("更新合伙人系统跑马灯")
	}

	b.NewLog(LogHorse, OpDelete, msg, map[string]interface{}{})

}

// @Title 跑马灯列表
// @Description 跑马灯列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Horse   跑马灯列表
// @router /horse/list-horse  [post]
func (b *RunController) ListHorse() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListHorse(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	// 1-未启用,2-启用中,3-已过期
	now := time.Now().Unix()
	for _, v := range data {
		if v.PublishTime > now { //未启用
			v.PublishStatus = 1
		} else if v.ExpireTime < now { //已过期
			v.PublishStatus = 3
		} else { //启用中
			v.PublishStatus = 2
		}

	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 推送跑马灯(游戏客户端)
// @Description 推送跑马灯(游戏客户端)
// @Param   content      body   string     true       "跑马灯的内容"
// @Param   time         body   int        true       "跑马灯滚动显示次数"
// @Success 0 {string}  状态码
// @router /horse/push-horse [post]
func (b *RunController) PushHorse() {
	type Params struct {
		Content string `json:"content"`
		Time    int64  `json:"time"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Content, "content").Message("跑马灯内容不能为空")
	b.Valid.Required(p.Content, "time").Message("跑马灯滚动次数不能为0")
	if !b.VerifyParamsError() {
		return
	}
	if client.BroadCastMsgToLobby(0, GenBroadcastMsg(ModuleHorse, ActionNewHorse, p)) {
		b.ResponseSuccess()
	}
	b.ResponseFail()

	msg := fmt.Sprintf("新增推送跑马灯,内容为:%v", p.Content)
	b.NewLog(LogHorse, OpNew, msg, map[string]interface{}{})

}

// @Title 新建全服邮件
// @Description 新建全服邮件
// @Param   expiretime   body   int        true        "过期时间"
// @Param   ptime        body   int        true        "发布时间"
// @Param   title        body   string     true        "标题"
// @Param   content      body   string     true        "内容"
// @Param   attachment   body   string     false       "附件,type: 1-钻石,2-金币 [{"qty":10,"type":1},{"qty":20,"type":2}]"
// @Param   nickname     body   int        true        "发送者昵称，如系统消息"
// @Success 0 {string}  状态码
// @router /email-full/new-email-full [post]
func (b *RunController) NewEmailFull() {
	var p EmailFull
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Nickname, "nickname").Message("发送者昵称不能为空")
	b.Valid.Required(p.ExpireTime, "expiretime").Message("过期时间不能为空")
	b.Valid.Required(p.Title, "title").Message("标题不能为空")
	b.Valid.Required(p.Content, "content").Message("内容不能为空")
	if !b.ValidParams(&p) {
		return
	}

	if p.PTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"title":      p.Title,
		"content":    p.Content,
		"attachment": p.Attachment,
		"nickname":   p.Nickname,
		"ptime":      p.PTime,
		"expiretime": p.ExpireTime,
		"status":     0,
	}
	_, err := pc.NewEmailFull(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("新建全服邮件")
	b.NewLog(LogEmail, OpNew, msg, data)
}

// @Title 更新全服邮件
// @Description 更新全服邮件
// @Param   efid         body   int        true        "邮件id"
// @Param   expiretime   body   int        true        "过期时间"
// @Param   ptime        body   int        true        "发布时间"
// @Param   title        body   string     true        "标题"
// @Param   content      body   string     true        "内容"
// @Param   attachment   body   string     false       "附件"
// @Param   nickname     body   int        true        "发送者昵称，如系统消息"
// @Success 0 {string}  状态码
// @router /email-full/update-email-full [post]
func (b *RunController) UpdateEmailFull() {
	var p EmailFull
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.EFid, "efid").Message("全服邮件id不能为0")
	b.Valid.Required(p.Nickname, "nickname").Message("发送者昵称不能为空")
	b.Valid.Required(p.ExpireTime, "expiretime").Message("过期时间不能为空")
	b.Valid.Required(p.Title, "title").Message("标题不能为空")
	b.Valid.Required(p.Content, "content").Message("内容不能为空")
	if !b.ValidParams(&p) {
		return
	}

	if p.PTime >= p.ExpireTime {
		b.ResponseFail("过期时间不能小于发布时间")
		return
	}

	data := map[string]interface{}{
		"title":      p.Title,
		"content":    p.Content,
		"attachment": p.Attachment,
		"nickname":   p.Nickname,
		"ptime":      p.PTime,
		"expiretime": p.ExpireTime,
	}
	err := pc.UpdateEmailFull(data, p.EFid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	msg := fmt.Sprintf("更新全服(ID:%v)邮件", p.EFid)
	b.NewLog(LogEmail, OpUpdate, msg, data)
}

// @Title 更新全服邮件状态
// @Description 更新全服邮件状态
// @Param   efid           body   int        true       "id"
// @Param   status       body   int        true       "此公告的状态(0正常,1下架)"
// @Success 0 {string}  状态码
// @router /email-full/update-email-full-status [post]
func (b *RunController) UpdateEmailFullStatus() {
	type Params struct {
		EFid   int64 `json:"efid" valid:"Required"`
		Status int64 `json:"status" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	data := map[string]interface{}{
		"status": p.Status,
	}
	err := pc.UpdateEmailFull(data, p.EFid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	msg := fmt.Sprintf("更新全服(ID:%v)邮件状态为正常", p.EFid)
	if p.Status == 1 {
		msg = fmt.Sprintf("更新全服(ID:%v)邮件状态为下架", p.EFid)
	}
	b.NewLog(LogEmail, OpUpdate, msg, data)

}

// @Title 全服邮件信息
// @Description 全服邮件信息
// @Param   efid          body   int        true        "邮件id"
// @Success 0 {string}  common.Bank
// @router /email-full/email-full-info [post]
func (b *RunController) EmailFullInfo() {
	type Params struct {
		EFid int64 `json:"efid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.EmailFullInfoById(p.EFid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title 获取全服邮件列表
// @Description  获取全服邮件列表
// @Param   page_size    body   int        true       "每页显示数量"
// @Param   page_index   body   int        true       "第几页"
// @Param   nickname     body   string     false      "发送人"
// @Param   status       body   int        false      ""
// @Success 0 {object} []common.EmailFull
// @Failure 399
// @router /email-full/list-email-full  [post]
func (b *RunController) ListEmailFull() {
	type Params struct {
		Nickname      string `json:"nickname"`
		Status        int64  `json:"status"`
		PublishStatus int64  `json:"publish_status"`
		ListDayParams
		ListParams
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	emails, count, err := pc.ListEmailFull(p.ListParams, p.ListDayParams, p.Nickname, p.Status, p.PublishStatus)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	// 1-未启用,2-启用中,3-已过期
	now := time.Now().Unix()
	for _, v := range emails {
		if v.PTime > now { //未启用
			v.PublishStatus = 1
		} else if v.ExpireTime < now { //已过期
			v.PublishStatus = 3
		} else { //启用中
			v.PublishStatus = 2
		}
	}

	b.Res.Data = emails
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 删除全服邮件
// @Description 删除全服邮件
// @Param   efid         body   int        true        "邮件id"
// @Success 0 {string}  状态码
// @router /email-full/delete-email-full [post]
func (b *RunController) DeleteEmailFull() {
	type Params struct {
		EFId int64 `json:"efid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteEmailFull(p.EFId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除全服邮件(ID:%v)", p.EFId)
	b.NewLog(LogEmail, OpDelete, msg, map[string]interface{}{})
}

// @Title 新建玩家邮件
// @Description 新建玩家邮件
// @Param   type         body   int        true        "消息类型(1系统消息2兑换通知,3支付通知,4好友邮件)"
// @Param   ruid         body   int        true        "接收者id"
// @Param   title        body   string     true        "标题"
// @Param   content      body   string     true        "内容"
// @Param   attachment   body   string     false        "附件,type: 1-钻石,2-金币 [{"qty":10,"type":1},{"qty":20,"type":2}]"
// @Param   send_time    body   string     true        "发送时间"
// @Success 0 {string}  状态码
// @router /email/new-email [post]
func (b *RunController) NewEmail() {
	var p Email
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Range(p.Type, 1, 3, "type").Message("取值范围1-3")
	b.Valid.Required(p.RUid, "ruid").Message("接收者id不能为0")
	b.Valid.Required(p.Title, "title").Message("标题不能为空")
	b.Valid.Required(p.Content, "content").Message("内容不能为空")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"type":       p.Type,
		"suid":       0, //系统发送的
		"nickname":   "系统消息",
		"ruid":       p.RUid,
		"title":      p.Title,
		"content":    p.Content,
		"attachment": p.Attachment,
		"status":     0,
		"is_get":     0,
		"send_time":  p.SendTime,
	}
	_, err := client.NewEmail(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	client.BroadCastMsgToLobby(0, GenBroadcastMsg(ModuleEmail, ActionNewEmail, ""), p.RUid)

	msg := fmt.Sprintf("新建玩家(uid:%v)邮件", p.RUid)
	b.NewLog(LogEmail, OpNew, msg, data)

}

// @Title 更新玩家邮件
// @Description 更新玩家邮件
// @Param   eid          body   int        true        "邮件id"
// @Param   type         body   int        true        "消息类型(1系统消息2兑换通知,3支付通知,4好友邮件)"
// @Param   suid         body   int        true        "发送者id,0-系统发送，非好友之间发送"
// @Param   nickname     body   int        true        "发送者昵称，如系统消息"
// @Param   ruid         body   int        true        "接收者id"
// @Param   title        body   string     true        "标题"
// @Param   content      body   string     true        "内容"
// @Param   attachment   body   string     false       "附件"
// @Param   send_time    body   string     true        "发送时间"
// @Success 0 {string}  状态码
// @router /email/update-email [post]
func (b *RunController) UpdateEmail() {
	var p Email
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Eid, "eid").Message("邮件id不能为0")
	b.Valid.Range(p.Type, 1, 3, "type").Message("取值范围1-3")
	b.Valid.Required(p.RUid, "ruid").Message("接收者id不能为0")
	b.Valid.Required(p.Title, "title").Message("标题不能为空")
	b.Valid.Required(p.Content, "content").Message("内容不能为空")
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"type":       p.Type,
		"suid":       p.SUid,
		"ruid":       p.RUid,
		"title":      p.Title,
		"content":    p.Content,
		"attachment": p.Attachment,
		"send_time":  p.SendTime,
	}
	err := pc.UpdateEmail(data, p.Eid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	client.BroadCastMsgToLobby(0, GenBroadcastMsg(ModuleEmail, ActionNewEmail, ""), p.RUid)

	msg := fmt.Sprintf("更新玩家(uid:%v)邮件", p.RUid)
	b.NewLog(LogEmail, OpUpdate, msg, data)
}

// @Title 邮件信息
// @Description 邮件信息
// @Param   eid          body   int        true        "邮件id"
// @Success 0 {string}  common.Bank
// @router /email/email-info [post]
func (b *RunController) EmailInfo() {
	type Params struct {
		Eid int64 `json:"eid" valid::"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, err := pc.EmailInfoById(p.Eid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.ResponseSuccess()
}

// @Title 获取邮件列表
// @Description 获取邮件列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Email
// @Failure 399
// @router /email/list-email  [post]
func (b *RunController) ListEmail() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	emails, count, err := pc.ListEmail(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	now := time.Now().Unix()
	for _, v := range emails {
		if v.SendTime > now { //发送时间还未到，可编辑
			v.Mutable = 1
		}
	}

	b.Res.Data = emails
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 删除玩家邮件
// @Description 删除玩家邮件
// @Param   eid         body   int        true        "邮件id"
// @Success 0 {string}  状态码
// @router /email/delete-email [post]
func (b *RunController) DeleteEmail() {
	type Params struct {
		EId int64 `json:"eid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteEmail(p.EId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除玩家邮件(ID:%v)", p.EId)
	b.NewLog(LogEmail, OpDelete, msg, map[string]interface{}{})
}

// @Title 更新反馈的状态为已处理
// @Description 更新反馈的状态为已处理
// @Param   id      body   int   true      "id"
// @Param   type    body    int   true     "类型,1-h5用户反馈,2-游戏用户反馈"
// @Success 0 {string} 返回房间信息
// @router /feedback/update-feedback-status [post]
func (b *RunController) UpdateFeedbackStatus() {
	type Params struct {
		Id   int64 `json:"id" valid:"Required"`
		Type int64 `json:"type" valid:"Range(1,2)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data := map[string]interface{}{
		"status":      1, //已处理此反馈
		"update_time": time.Now().Unix(),
		"operator_id": b.Uid,
	}
	_, err := pc.UpdateFeedbackStatus(data, p.Id, p.Type)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
}

// @Title 玩家与h5用户反馈列表
// @Description 玩家与h5用户反馈列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   type         body   int     true       "类型,1-h5用户反馈,2-游戏用户反馈"
// @Success 0 {object} [] 反馈列表
// @router /feedback/list-feedback [post]
func (b *RunController) ListFeedback() {
	type Params struct {
		ListParams
		Type int64 `json:"type" valid:"Range(1,2)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListFeedback(p.ListParams, p.Type)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

//-----------------------------------上下分白名单-----------------------------------------------------------
// @Title 查询玩家信息
// @Description 查询玩家信息
// @Param   uid        body   int        true        "玩家id"
// @Success 0 {string}  状态码
// @router /white/query-user-info [post]
func (b *RunController) QueryUserInfo() {
	type Params struct {
		Uid int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if p.Uid == 0 {
		b.ResponseFail("请输入有效的玩家ID")
		return
	}
	user, err := client.QueryUserInfoById(p.Uid)
	if err != nil {
		LogH5.Error(b.DatabaseError(err.Error()))
		return
	}
	if user.Uid != p.Uid {
		b.ResponseFail("玩家不存在,请检查")
		return
	}
	b.Res.Data = user
	b.ResponseSuccess()
}

// @Title 添加玩家id进白色单
// @Description 添加玩家id进白色单
// @Param   uid        body   int        true        "玩家id"
// @Success 0 {string}  状态码
// @router /white/add-white-user [post]
func (b *RunController) AddWhiteUser() {
	type Params struct {
		Uid int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if p.Uid == 0 {
		b.ResponseFail("请输入有效的玩家ID")
		return
	}
	user, err := client.QueryUserInfoById(p.Uid)
	if err != nil {
		LogH5.Error(b.DatabaseError(err.Error()))
		return
	}
	if user.Uid == 0 {
		b.ResponseFail("玩家ID不存在,请检查")
		return
	}
	id, _ := pc.WhiteUserById(p.Uid)
	if id == p.Uid {
		b.ResponseFail("此用户已添加白名单,无须重复添加")
		return
	}

	data := map[string]interface{}{
		"uid":         p.Uid,
		"is_contest":  1,
		"create_time": time.Now().Unix(),
	}
	_, err = pc.NewWhiteUser(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	_, err = pc.UpdateClubContest(p.Uid, 1)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("添加玩家(ID:%v)到白名单", p.Uid)
	b.NewLog(LogRun, OpNew, msg, data)

}

// @Title 白名单玩家列表
// @Description 白名单玩家列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []白名单
// @router /white/list-white-user [post]
func (b *RunController) ListWhiteUser() {
	type Params struct {
		ListParams
		Uid int64 `json:"uid"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	cr, count, err := pc.ListWhiteUser(p.ListParams, p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Count = count
	b.Res.Data = cr
	b.ResponseSuccess()
}

// @Title 更新白名单玩家(启用禁用)
// @Description 更新白名单玩家(启用禁用)
// @Param   uid  	   body   int        true        "玩家ID,传输形式 [1,2,3,4,5]"
// @Param   is_contest body   int        true        "1-启用玩家上下分功能,0-禁用玩家上下分功能"
// @Success 0 {string}  状态码
// @router /white/update-white-user [post]
func (b *RunController) UpdateWhiteUser() {
	type Params struct {
		Uid       []int64 `json:"uid" valid:"Required"`
		IsContest int64   `json:"is_contest" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	for _, v := range p.Uid {
		_, err := pc.UpdateClubContest(v, p.IsContest)
		if err != nil {
			LogPc.Error(b.DatabaseError(err.Error()))
			return
		}
	}

	b.ResponseSuccess()

	msg := fmt.Sprintf("禁用玩家上下分功能(ID:%v)", p.Uid)
	if p.IsContest == 1 {
		msg = fmt.Sprintf("启用玩家上下分功能(ID:%v)", p.Uid)
	}
	b.NewLog(LogRun, OpUpdate, msg, map[string]interface{}{})
}

// @Title 删除白名单玩家
// @Description 删除白名单玩家
// @Param   uid body   int        true        "玩家ID"
// @Success 0 {string}  状态码
// @router /white/delete-white-user [post]
func (b *RunController) DeleteWhiteUser() {
	type Params struct {
		Uid int64 `json:"uid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.UpdateClubContest(p.Uid, 0)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	_, err = pc.DeleteWhiteUser(p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	msg := fmt.Sprintf("从白名单里移出玩家(ID:%v)", p.Uid)
	b.NewLog(LogRun, OpDelete, msg, map[string]interface{}{})
}

//------------------------------------大区游戏---------------------------------------
// @Title 添加游戏到大区
// @Description 添加游戏到大区
// @Param   game_id        body   int        true        "游戏id"
// @Param   group_id       body   int        true        "大区id"
// @Success 0 {string}  状态码
// @router /group-game/add-group-game [post]
func (b *RunController) AddGroupGame() {
	type Params struct {
		GroupId int64 `json:"group_id" valid:"Required"`
		GameId  int64 `json:"game_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	ok, err := pc.GroupGameById(p.GroupId, p.GameId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	if ok {
		b.ResponseFail("此游戏已添加大区列表,无须重复添加")
		return
	}

	data := map[string]interface{}{
		"group_id":     p.GroupId,
		"game_id":      p.GameId,
		"operator_uid": b.Uid,
		"create_time":  time.Now().Unix(),
	}
	_, err = pc.NewGroupGame(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("添加游戏(ID:%v)到大区(ID:%v)", p.GameId, p.GroupId)
	b.NewLog(LogRun, OpNew, msg, data)

}

// @Title 大区游戏列表
// @Description 大区游戏列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   group_id     body   int     true       "大区id"
// @Success 0 {object} []白名单
// @router /group-game/list-group-game [post]
func (b *RunController) ListGroupGame() {
	type Params struct {
		ListParams
		GroupId int64 `json:"group_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	cr, count, err := pc.ListGroupGame(p.ListParams, p.GroupId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Count = count
	b.Res.Data = cr
	b.ResponseSuccess()
}

// @Title 删除大区游戏
// @Description 删除大区游戏
// @Param   group_id  body   int        true        "大区id"
// @Param   game_id   body   int        true        "游戏id"
// @Success 0 {string}  状态码
// @router /group-game/delete-group-game [post]
func (b *RunController) DeleteGroupGame() {
	type Params struct {
		GroupId int64 `json:"group_id" valid:"Required"`
		GameId  int64 `json:"game_id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	_, err := pc.DeleteGroupGame(p.GroupId, p.GameId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	msg := fmt.Sprintf("从大区(ID:%v)删除游戏(ID:%v)", p.GroupId, p.GameId)
	b.NewLog(LogRun, OpDelete, msg, map[string]interface{}{})
}
